//// stl_hash_set
//template <class Value, class HashFcn = hash<Value>,
//	class EqualKey = equal_to<Value>,
//	class Alloc = alloc>
//class hash_set
//{
//private:
//	typedef hashtable<Value, Value, HashFcn, identity<Value>,
//		EqualKey, Alloc> ht;
//	ht rep;
//public:
//	typedef typename ht::key_type key_type;
//	typedef typename ht::value_type value_type;
//	typedef typename ht::hasher hasher;
//	typedef typename ht::key_equal key_equal;
//	typedef typename ht::const_iterator iterator;
//	typedef typename ht::const_iterator const_iterator;
//	hasher hash_funct() const { return rep.hash_funct(); }
//	key_equal key_eq() const { return rep.key_eq(); }
//};
//// stl_hash_map
//template <class Key, class T, class HashFcn = hash<Key>,
//	class EqualKey = equal_to<Key>,
//	class Alloc = alloc>
//class hash_map
//{
//private:
//	typedef hashtable<pair<const Key, T>, Key, HashFcn,
//		select1st<pair<const Key, T> >, EqualKey, Alloc> ht;
//	ht rep;
//public:
//	typedef typename ht::key_type key_type;
//	typedef T data_type;
//	typedef T mapped_type;
//	typedef typename ht::value_type value_type;
//	typedef typename ht::hasher hasher;
//	typedef typename ht::key_equal key_equal;
//	typedef typename ht::iterator iterator;
//	typedef typename ht::const_iterator const_iterator;
//};
//// stl_hashtable.h
//template <class Value, class Key, class HashFcn,
//	class ExtractKey, class EqualKey,
//	class Alloc>
//class hashtable {
//public:
//	typedef Key key_type;
//	typedef Value value_type;
//	typedef HashFcn hasher;
//	typedef EqualKey key_equal;
//private:
//	hasher hash;
//	key_equal equals;
//	ExtractKey get_key;
//	typedef __hashtable_node<Value> node;
//	vector<node*, Alloc> buckets;
//	size_type num_elements;
//public:
//	typedef __hashtable_iterator<Value, Key, HashFcn, ExtractKey, EqualKey,
//		Alloc> iterator;
//	pair<iterator, bool> insert_unique(const value_type& obj);
//	const_iterator find(const key_type& key) const;
//};
//template <class Value>
//struct __hashtable_node
//{
//	__hashtable_node* next;
//	Value val;
//};

//// MyUnorderedSet.h
//namespace sy
//{
//	template<class K, class Hash = HashFunc<K>>
//	class unordered_set
//	{
//		struct SetKeyOfT
//		{
//			const K& operator()(const K& key)
//			{
//				return key;
//			}
//		};
//	public:
//		bool insert(const K& key)
//		{
//			return _ht.Insert(key);
//		}
//	private:
//		hash_bucket::HashTable<K, K, SetKeyOfT, Hash> _ht;
//	};
//}
//// MyUnorderedMap.h
//namespace sy
//{
//	template<class K, class V, class Hash = HashFunc<K>>
//	class unordered_map
//	{
//		struct MapKeyOfT
//		{
//			const K& operator()(const pair<K, V>& kv)
//			{
//				return kv.first;
//			}
//		};
//	public:
//		bool insert(const pair<K, V>& kv)
//		{
//			return _ht.Insert(kv);
//		}
//	private:
//		hash_bucket::HashTable<K, pair<K, V>, MapKeyOfT, Hash> _ht;
//	};
//}
//template <class Value, class Key, class HashFcn,
//	class ExtractKey, class EqualKey, class Alloc>
//struct __hashtable_iterator {
//	typedef hashtable<Value, Key, HashFcn, ExtractKey, EqualKey, Alloc>
//		hashtable;
//	typedef __hashtable_iterator<Value, Key, HashFcn,
//		ExtractKey, EqualKey, Alloc>
//		iterator;
//	typedef __hashtable_const_iterator<Value, Key, HashFcn,
//		ExtractKey, EqualKey, Alloc>
//		const_iterator;
//	typedef __hashtable_node<Value> node;
//	typedef forward_iterator_tag iterator_category;
//	typedef Value value_type;
//	node* cur;
//	hashtable* ht;
//	__hashtable_iterator(node* n, hashtable* tab) : cur(n), ht(tab) {}
//	__hashtable_iterator() {}
//	reference operator*() const { return cur->val; }
//#ifndef __SGI_STL_NO_ARROW_OPERATOR
//	pointer operator->() const { return &(operator*()); }
//#endif /* __SGI_STL_NO_ARROW_OPERATOR */
//	iterator & operator++();
//	iterator operator++(int);
//	bool operator==(const iterator& it) const { return cur == it.cur; }
//	bool operator!=(const iterator& it) const { return cur != it.cur; }
//};
//template <class V, class K, class HF, class ExK, class EqK, class A>
//__hashtable_iterator<V, K, HF, ExK, EqK, A>&
//__hashtable_iterator<V, K, HF, ExK, EqK, A>::operator++()
//{
//	const node* old = cur;
//	cur = cur->next;
//	if (!cur) {
//		size_type bucket = ht->bkt_num(old->val);
//		while (!cur && ++bucket < ht->buckets.size())
//			cur = ht->buckets[bucket];
//	}
//	return *this;
//}